/*
 * Copyright (c) 1999, 2005, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package javax.sound.sampled;

import java.io.InputStream;
import java.io.PushbackInputStream;
import java.io.IOException;


/**
 * An audio input stream is an input stream with a specified audio format and
 * length.  The length is expressed in sample frames, not bytes.
 * Several methods are provided for reading a certain number of bytes from
 * the stream, or an unspecified number of bytes.
 * The audio input stream keeps track  of the last byte that was read.
 * You can skip over an arbitrary number of bytes to get to a later position
 * for reading. An audio input stream may support marks.  When you set a mark,
 * the current position is remembered so that you can return to it later.
 * <p>
 * The <code>AudioSystem</code> class includes many methods that manipulate
 * <code>AudioInputStream</code> objects.
 * For example, the methods let you:
 * <ul>
 * <li> obtain an
 * audio input stream from an external audio file, stream, or URL
 * <li> write an external file from an audio input stream
 * <li> convert an audio input stream to a different audio format
 * </ul>
 *
 * @author David Rivas
 * @author Kara Kytle
 * @author Florian Bomers
 * @see AudioSystem
 * @see Clip#open(AudioInputStream) Clip.open(AudioInputStream)
 * @since 1.3
 */
public class AudioInputStream extends InputStream {

  /**
   * The <code>InputStream</code> from which this <code>AudioInputStream</code>
   * object was constructed.
   */
  private InputStream stream;

  /**
   * The format of the audio data contained in the stream.
   */
  protected AudioFormat format;

  /**
   * This stream's length, in sample frames.
   */
  protected long frameLength;

  /**
   * The size of each frame, in bytes.
   */
  protected int frameSize;

  /**
   * The current position in this stream, in sample frames (zero-based).
   */
  protected long framePos;

  /**
   * The position where a mark was set.
   */
  private long markpos;

  /**
   * When the underlying stream could only return
   * a non-integral number of frames, store
   * the remainder in a temporary buffer
   */
  private byte[] pushBackBuffer = null;

  /**
   * number of valid bytes in the pushBackBuffer
   */
  private int pushBackLen = 0;

  /**
   * MarkBuffer at mark position
   */
  private byte[] markPushBackBuffer = null;

  /**
   * number of valid bytes in the markPushBackBuffer
   */
  private int markPushBackLen = 0;


  /**
   * Constructs an audio input stream that has the requested format and length in sample frames,
   * using audio data from the specified input stream.
   *
   * @param stream the stream on which this <code>AudioInputStream</code> object is based
   * @param format the format of this stream's audio data
   * @param length the length in sample frames of the data in this stream
   */
  public AudioInputStream(InputStream stream, AudioFormat format, long length) {

    super();

    this.format = format;
    this.frameLength = length;
    this.frameSize = format.getFrameSize();

    // any frameSize that is not well-defined will
    // cause that this stream will be read in bytes
    if (this.frameSize == AudioSystem.NOT_SPECIFIED || frameSize <= 0) {
      this.frameSize = 1;
    }

    this.stream = stream;
    framePos = 0;
    markpos = 0;
  }


  /**
   * Constructs an audio input stream that reads its data from the target
   * data line indicated.  The format of the stream is the same as that of
   * the target data line, and the length is AudioSystem#NOT_SPECIFIED.
   *
   * @param line the target data line from which this stream obtains its data.
   * @see AudioSystem#NOT_SPECIFIED
   */
  public AudioInputStream(TargetDataLine line) {

    TargetDataLineInputStream tstream = new TargetDataLineInputStream(line);
    format = line.getFormat();
    frameLength = AudioSystem.NOT_SPECIFIED;
    frameSize = format.getFrameSize();

    if (frameSize == AudioSystem.NOT_SPECIFIED || frameSize <= 0) {
      frameSize = 1;
    }
    this.stream = tstream;
    framePos = 0;
    markpos = 0;
  }


  /**
   * Obtains the audio format of the sound data in this audio input stream.
   *
   * @return an audio format object describing this stream's format
   */
  public AudioFormat getFormat() {
    return format;
  }


  /**
   * Obtains the length of the stream, expressed in sample frames rather than bytes.
   *
   * @return the length in sample frames
   */
  public long getFrameLength() {
    return frameLength;
  }


  /**
   * Reads the next byte of data from the audio input stream.  The audio input
   * stream's frame size must be one byte, or an <code>IOException</code>
   * will be thrown.
   *
   * @return the next byte of data, or -1 if the end of the stream is reached
   * @throws IOException if an input or output error occurs
   * @see #read(byte[], int, int)
   * @see #read(byte[])
   * @see #available <p>
   */
  public int read() throws IOException {
    if (frameSize != 1) {
      throw new IOException("cannot read a single byte if frame size > 1");
    }

    byte[] data = new byte[1];
    int temp = read(data);
    if (temp <= 0) {
      // we have a weird situation if read(byte[]) returns 0!
      return -1;
    }
    return data[0] & 0xFF;
  }


  /**
   * Reads some number of bytes from the audio input stream and stores them into
   * the buffer array <code>b</code>. The number of bytes actually read is
   * returned as an integer. This method blocks until input data is
   * available, the end of the stream is detected, or an exception is thrown.
   * <p>This method will always read an integral number of frames.
   * If the length of the array is not an integral number
   * of frames, a maximum of <code>b.length - (b.length % frameSize)
   * </code> bytes will be read.
   *
   * @param b the buffer into which the data is read
   * @return the total number of bytes read into the buffer, or -1 if there is no more data because
   * the end of the stream has been reached
   * @throws IOException if an input or output error occurs
   * @see #read(byte[], int, int)
   * @see #read()
   * @see #available
   */
  public int read(byte[] b) throws IOException {
    return read(b, 0, b.length);
  }


  /**
   * Reads up to a specified maximum number of bytes of data from the audio
   * stream, putting them into the given byte array.
   * <p>This method will always read an integral number of frames.
   * If <code>len</code> does not specify an integral number
   * of frames, a maximum of <code>len - (len % frameSize)
   * </code> bytes will be read.
   *
   * @param b the buffer into which the data is read
   * @param off the offset, from the beginning of array <code>b</code>, at which the data will be
   * written
   * @param len the maximum number of bytes to read
   * @return the total number of bytes read into the buffer, or -1 if there is no more data because
   * the end of the stream has been reached
   * @throws IOException if an input or output error occurs
   * @see #read(byte[])
   * @see #read()
   * @see #skip
   * @see #available
   */
  public int read(byte[] b, int off, int len) throws IOException {

    // make sure we don't read fractions of a frame.
    if ((len % frameSize) != 0) {
      len -= (len % frameSize);
      if (len == 0) {
        return 0;
      }
    }

    if (frameLength != AudioSystem.NOT_SPECIFIED) {
      if (framePos >= frameLength) {
        return -1;
      } else {

        // don't try to read beyond our own set length in frames
        if ((len / frameSize) > (frameLength - framePos)) {
          len = (int) (frameLength - framePos) * frameSize;
        }
      }
    }

    int bytesRead = 0;
    int thisOff = off;

    // if we've bytes left from last call to read(),
    // use them first
    if (pushBackLen > 0 && len >= pushBackLen) {
      System.arraycopy(pushBackBuffer, 0,
          b, off, pushBackLen);
      thisOff += pushBackLen;
      len -= pushBackLen;
      bytesRead += pushBackLen;
      pushBackLen = 0;
    }

    int thisBytesRead = stream.read(b, thisOff, len);
    if (thisBytesRead == -1) {
      return -1;
    }
    if (thisBytesRead > 0) {
      bytesRead += thisBytesRead;
    }
    if (bytesRead > 0) {
      pushBackLen = bytesRead % frameSize;
      if (pushBackLen > 0) {
        // copy everything we got from the beginning of the frame
        // to our pushback buffer
        if (pushBackBuffer == null) {
          pushBackBuffer = new byte[frameSize];
        }
        System.arraycopy(b, off + bytesRead - pushBackLen,
            pushBackBuffer, 0, pushBackLen);
        bytesRead -= pushBackLen;
      }
      // make sure to update our framePos
      framePos += bytesRead / frameSize;
    }
    return bytesRead;
  }


  /**
   * Skips over and discards a specified number of bytes from this
   * audio input stream.
   *
   * @param n the requested number of bytes to be skipped
   * @return the actual number of bytes skipped
   * @throws IOException if an input or output error occurs
   * @see #read
   * @see #available
   */
  public long skip(long n) throws IOException {

    // make sure not to skip fractional frames
    if ((n % frameSize) != 0) {
      n -= (n % frameSize);
    }

    if (frameLength != AudioSystem.NOT_SPECIFIED) {
      // don't skip more than our set length in frames.
      if ((n / frameSize) > (frameLength - framePos)) {
        n = (frameLength - framePos) * frameSize;
      }
    }
    long temp = stream.skip(n);

    // if no error, update our position.
    if (temp % frameSize != 0) {

      // Throw an IOException if we've skipped a fractional number of frames
      throw new IOException("Could not skip an integer number of frames.");
    }
    if (temp >= 0) {
      framePos += temp / frameSize;
    }
    return temp;

  }


  /**
   * Returns the maximum number of bytes that can be read (or skipped over) from this
   * audio input stream without blocking.  This limit applies only to the next invocation of
   * a <code>read</code> or <code>skip</code> method for this audio input stream; the limit
   * can vary each time these methods are invoked.
   * Depending on the underlying stream,an IOException may be thrown if this
   * stream is closed.
   *
   * @return the number of bytes that can be read from this audio input stream without blocking
   * @throws IOException if an input or output error occurs
   * @see #read(byte[], int, int)
   * @see #read(byte[])
   * @see #read()
   * @see #skip
   */
  public int available() throws IOException {

    int temp = stream.available();

    // don't return greater than our set length in frames
    if ((frameLength != AudioSystem.NOT_SPECIFIED) && ((temp / frameSize) > (frameLength
        - framePos))) {
      return (int) (frameLength - framePos) * frameSize;
    } else {
      return temp;
    }
  }


  /**
   * Closes this audio input stream and releases any system resources associated
   * with the stream.
   *
   * @throws IOException if an input or output error occurs
   */
  public void close() throws IOException {
    stream.close();
  }


  /**
   * Marks the current position in this audio input stream.
   *
   * @param readlimit the maximum number of bytes that can be read before the mark position becomes
   * invalid.
   * @see #reset
   * @see #markSupported
   */

  public void mark(int readlimit) {

    stream.mark(readlimit);
    if (markSupported()) {
      markpos = framePos;
      // remember the pushback buffer
      markPushBackLen = pushBackLen;
      if (markPushBackLen > 0) {
        if (markPushBackBuffer == null) {
          markPushBackBuffer = new byte[frameSize];
        }
        System.arraycopy(pushBackBuffer, 0, markPushBackBuffer, 0, markPushBackLen);
      }
    }
  }


  /**
   * Repositions this audio input stream to the position it had at the time its
   * <code>mark</code> method was last invoked.
   *
   * @throws IOException if an input or output error occurs.
   * @see #mark
   * @see #markSupported
   */
  public void reset() throws IOException {

    stream.reset();
    framePos = markpos;
    // re-create the pushback buffer
    pushBackLen = markPushBackLen;
    if (pushBackLen > 0) {
      if (pushBackBuffer == null) {
        pushBackBuffer = new byte[frameSize - 1];
      }
      System.arraycopy(markPushBackBuffer, 0, pushBackBuffer, 0, pushBackLen);
    }
  }


  /**
   * Tests whether this audio input stream supports the <code>mark</code> and
   * <code>reset</code> methods.
   *
   * @return <code>true</code> if this stream supports the <code>mark</code> and <code>reset</code>
   * methods; <code>false</code> otherwise
   * @see #mark
   * @see #reset
   */
  public boolean markSupported() {

    return stream.markSupported();
  }


  /**
   * Private inner class that makes a TargetDataLine look like an InputStream.
   */
  private class TargetDataLineInputStream extends InputStream {

    /**
     * The TargetDataLine on which this TargetDataLineInputStream is based.
     */
    TargetDataLine line;


    TargetDataLineInputStream(TargetDataLine line) {
      super();
      this.line = line;
    }


    public int available() throws IOException {
      return line.available();
    }

    //$$fb 2001-07-16: added this method to correctly close the underlying TargetDataLine.
    // fixes bug 4479984
    public void close() throws IOException {
      // the line needs to be flushed and stopped to avoid a dead lock...
      // Probably related to bugs 4417527, 4334868, 4383457
      if (line.isActive()) {
        line.flush();
        line.stop();
      }
      line.close();
    }

    public int read() throws IOException {

      byte[] b = new byte[1];

      int value = read(b, 0, 1);

      if (value == -1) {
        return -1;
      }

      value = (int) b[0];

      if (line.getFormat().getEncoding().equals(AudioFormat.Encoding.PCM_SIGNED)) {
        value += 128;
      }

      return value;
    }


    public int read(byte[] b, int off, int len) throws IOException {
      try {
        return line.read(b, off, len);
      } catch (IllegalArgumentException e) {
        throw new IOException(e.getMessage());
      }
    }
  }
}
